﻿// 0726train02.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
#include <string>
#include <sstream>
#include <vector>
#include <stack>
#include <map>

using namespace std;
/*
 字符串列表 ops，其中 ops[i] 是你需要记录的第 i 项操作，ops 遵循下述规则：
1. 整数 x 表示本回合新获得分数 x
2. + 表示本回合新获得的得分是前两次得分的总和。
3. D 表示本回合新获得的得分是前一次得分的两倍。
4. C 表示本回合没有分数，并且前一次得分无效，将其从记录中移除。
请你返回记录中所有得分的总和。

输入
5 2 C D +
输出
30

5 记录加 5 ，记录现在是 [5]
2 记录加 2 ，记录现在是 [5, 2]
C 使前一次得分的记录无效并将其移除，记录现在是 [5].
D 记录加 2 * 5 = 10 ，记录现在是 [5, 10].
+ 记录加 5 + 10 = 15 ，记录现在是 [5, 10, 15]
所有得分的总和 5 + 10 + 15 = 30
8 D + + +
152

 */

void solve1(vector<string>&operator_vec)
{
	//vector<string>operator_vec = { "5","2","C","D","+" };
	stack<int>oh_stack;

	int vec_size = operator_vec.size();
	for (int i=0; i< vec_size; i++)
	{
		string curr_op = operator_vec[i];
		if (curr_op == "C" && !oh_stack.empty())
		{
			oh_stack.pop();
		}
		else if (curr_op == "D")
		{
			if (oh_stack.empty())
			{
				cout << -1;
				return;
			}

			int double_top = 2 * oh_stack.top();
			oh_stack.push(double_top);
		}
		else if (curr_op == "+")
		{
			if (oh_stack.size() < 2)
			{
				cout << -1;
				return;
			}

			int first, second;
			if (!oh_stack.empty())
			{
				first = oh_stack.top();
				oh_stack.pop();
			}

			if (!oh_stack.empty())
			{
				second = oh_stack.top();
			}

			int new_top = first + second;
			oh_stack.push(first);
			oh_stack.push(new_top);

			//+ ------
			// ------
		}
		else
		{
			oh_stack.push(stoi(curr_op));
		}

		//for------
		//---------
	}

	int result = 0;
	while (!oh_stack.empty())
	{
		result += oh_stack.top();
		oh_stack.pop();
	}

	cout << result;
}



/*
 给定用户密码输入流 input，输入流中字符'<'表示退格，可以清除前一个输入的字符，
 请你编写程序，输出最终得到的密码字符，并判断密码是否满足如下的密码安全要求。
密码安全要求如下：
1. 密码长度>=8;
2. 密码至少需要包含 1 个大写字母;
3. 密码至少需要包含 1 个小写字母;
4. 密码至少需要包含 1 个数字;
5. 密码至少需要包含 1 个字母和数字以外的非空白特殊字符
注意空串退格后仍然为空串，且用户输入的字符串不包含'<'字符和空白字符。

输入描述
用一行字符串表示输入的用户数据，输入的字符串中'<'字符标识退格，
用户输入的字符串不包含空白字符，例如：ABC<c89%000<

输出描述
输出经过程序处理后，输出的实际密码字符串，并输出改密码字符串是否满足密码安全要求。
两者间由','分隔， 例如：ABc89%00,true


输入
ABC<c89%000<
输出
ABc89%00,true

 */

bool CheckSpecial(char oh_char)
{
	if (oh_char >= 'A' && oh_char <= 'Z')
	{
		return false;
	}
	//小写字母;
	if (oh_char >= 'a' && oh_char <= 'z')
	{
		return false;
	}

	//数字;
	if (oh_char >= '0' && oh_char <= '9')
	{
		return false;
	}

	if (oh_char == ' ') return false;
	return true;
}

bool CheckSecret(const string oh_str)
{
	bool result = false;
	//1. 密码长度 >= 8;
	if (oh_str.size()<8)
	{
		return result;
	}

	
	bool is_big = false;
	bool is_small = false;
	bool is_number = false;
	bool is_special = false;
	for (auto&item:oh_str)
	{
		//2. 密码至少需要包含 1 个大写字母;
		if (item>='A' && item<='Z')
		{
			is_big = true;
		}
		//3. 密码至少需要包含 1 个小写字母;
		if (item >= 'a' && item <= 'z')
		{
			is_small = true;
		}

		//4. 密码至少需要包含 1 个数字;
		if (item >= '0' && item <= '9')
		{
			is_number = true;
		}

		//5. 密码至少需要包含 1 个字母和数字以外的非空白特殊字符
		if (!is_special)
		{
			is_special = CheckSpecial(item);
		}
		//for------
		//---------
	}
	if (!is_big || !is_small || !is_number || !is_special)
	{
		return result;
	}


	result = true;
	return result;
	//CheckSecret
	//-------
}

void solve2(string oh_str)
{
	/*
	 * 输入
	ABC<c89%000<
	输出
	ABc89%00,true
	 */
	vector<char>oh_stack_vec;

	for (auto& oh_char:oh_str)
	{
		if (oh_char=='<')
		{
			if (oh_stack_vec.size()>0)
			{
				oh_stack_vec.pop_back();
			}
		}
		else
		{
			oh_stack_vec.push_back(oh_char);
		}
	}

	string format_str;
	for (auto &oh_char:oh_stack_vec)
	{
		format_str += oh_char;
	}

	cout << format_str;
	cout << ",";
	string check_res;
	check_res = CheckSecret(format_str) ? "true" : "false";
	cout << check_res;

	//solve2------
	//------------
}



/*
 *https://www.algomooc.com/problem/P2607
 题目描述
已知火星人使用的运算符号为 # 、$
他们与地球人的等价公式如下：
- x#y = 4*x+3*y+2
- x$y = 2*x+y+3
其中 x y 是无符号整数
地球人公式按照 C 语言规则进行计算
火星人公式中 # 符优先级高于 $
相同的运算符按从左到右的顺序运算

输入描述
火星人字符串表达式结尾不带回车换行

输入的字符串说明：
字符串为仅有无符号整数和操作符组成的计算表达式
1. 用例保证字符串中操作数与操作符之间没有任何分隔符
2. 用例保证操作数取值范围为 32 位无符号整数
3. 保证输入以及计算结果不会出现整型溢出
4. 保证输入的字符串为合法的求值报文
例如: 123#4$5#76$78
5. 保证不会出现非法的求值报文
例如：
- #4$5 这种缺少操作数；
- 4$5# 这种缺少操作数；
- 4#$5 这种缺少操作数；
- 4 $5 有空格；
- 3+4-5*6/7 有其他操作符；
- 12345678987654321$54321 32 位整数溢出

输出描述
根据火星人字符串输出计算结果，结尾不带回车换行

# 符优先级高于 $

- x#y = 4*x+3*y+2
- x$y = 2*x+y+3

输入
7#6$5#12

输出
157

 */



int computedStr31(string oh_str)
{
	string token;
	stringstream oh_sstream(oh_str);
	vector<int>number_vec;

	while (getline(oh_sstream, token, '#'))
	{
		number_vec.push_back(stoi(token));
	}

	//x#y = 4*x+3*y+2

	int result = 4 * number_vec[0] + 3 * number_vec[1] + 2;
	if (number_vec.size() < 2) return result;

	for (int i=2; i<number_vec.size();i++)
	{
		result = 4 * result + 3 * number_vec[i] + 2;
	}
	return result;
	//computedStr31
}

bool CheckNumber3(string oh_str)
{
	bool result = true;
	for (auto &oh_char:oh_str)
	{
		if (!(oh_char >= '0' && oh_char <= '9'))
		{
			result = false;
			break;
		}
	}

	return result;
}

int computedDollar3(string oh_str)
{
	stringstream oh_sstream(oh_str);
	string token;
	vector<string>str_vec;

	while (getline(oh_sstream, token, '$'))
	{
		str_vec.push_back(token);
	}

	//x$y = 2*x+y+3
	int result;
	stack<int>oh_stack;
	for (int i=0; i<str_vec.size();i++)
	{
		
		if (CheckNumber3(str_vec[i]))
		{
			int curr_num = stoi(str_vec[i]);
			if (!oh_stack.empty())
			{
				int prev = oh_stack.top();
				oh_stack.pop();

				curr_num = 2 * prev + curr_num + 3;
			}

			
			oh_stack.push(curr_num);
		}
		else
		{
			int curr_num = computedStr31(str_vec[i]);
			if (!oh_stack.empty())
			{
				int prev = oh_stack.top();
				oh_stack.pop();

				curr_num = 2 * prev + curr_num + 3;
			}

			oh_stack.push(curr_num);
		}
	}

	result = oh_stack.top();
	return result;
	//computedDollar3
}


bool CheckSingleNum(const char oh_char)
{
	if (oh_char >= '0' && oh_char <= '9')
	{
		return true;
	}
	return false;
}

bool CheckVerify3(string oh_str)
{
	int str_size = oh_str.size();
	if (!CheckSingleNum(oh_str[0]))
		return false;
	if (!CheckSingleNum(oh_str[str_size - 1]))
		return false;

	stack<char>oh_stack;
	for (int i=0; i<str_size;i++)
	{
		char oh_char = oh_str[i];

		if ((!CheckSingleNum(oh_char)) && (oh_char != '#') && (oh_char != '$'))
			return false;

		if (oh_char=='#' || oh_char=='$')
		{
			bool is_verify = true;
			while (!oh_stack.empty())
			{
				char top = oh_stack.top();
				oh_stack.pop();
				if (!CheckSingleNum(top))
				{
					is_verify = false;
					break;
				}
			}
			if (i + 1 < str_size && !CheckSingleNum(oh_str[i+1]))
				return false;

			if (!is_verify) return false;
		}
	}

	return true;

}

int main()
{

	{
		string input;
		getline(cin, input);
		if (CheckVerify3(input))
		{
			cout << computedDollar3(input);
		}

		return 0;
	}


	{
		string oh_str;
		cin >> oh_str;
		solve2(oh_str);
		//cout << CheckSpecial('%');
		return 0;
	}

	vector<string>operator_vec;
	string input;
	getline(cin, input);
	stringstream oh_sstream(input);
	string token;
	while (oh_sstream >> token)
	{
		operator_vec.push_back(token);
	}

	/*for (auto &item: operator_vec)
	{
		cout << item;
	}*/

	solve1(operator_vec);
}

// 运行程序: Ctrl + F5 或调试 >“开始执行(不调试)”菜单
// 调试程序: F5 或调试 >“开始调试”菜单

// 入门使用技巧: 
//   1. 使用解决方案资源管理器窗口添加/管理文件
//   2. 使用团队资源管理器窗口连接到源代码管理
//   3. 使用输出窗口查看生成输出和其他消息
//   4. 使用错误列表窗口查看错误
//   5. 转到“项目”>“添加新项”以创建新的代码文件，或转到“项目”>“添加现有项”以将现有代码文件添加到项目
//   6. 将来，若要再次打开此项目，请转到“文件”>“打开”>“项目”并选择 .sln 文件
